# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the read-only "../input/" directory
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session

import torch, gc
gc.collect()
torch.cuda.empty_cache()

import torch

if torch.cuda.is_available():
   
    num_devices = torch.cuda.device_count()
    print(f"Number of available GPUs: {num_devices}")
    
   
    for i in range(num_devices):
        device_name = torch.cuda.get_device_name(i)
        print(f"GPU {i}: {device_name}")
        
    
    max_memory_allocated = torch.cuda.max_memory_allocated()
    max_memory_reserved = torch.cuda.max_memory_reserved()
    print(f"Maximum GPU memory allocated: {max_memory_allocated/1024**3:.2f} GB")
    print(f"Maximum GPU memory reserved: {max_memory_reserved/1024**3:.2f} GB")
    print("CUDA is available:", torch.cuda.is_available())
else:
    print("CUDA is not available")

Number of available GPUs: 2
GPU 0: Tesla T4
GPU 1: Tesla T4
Maximum GPU memory allocated: 0.00 GB
Maximum GPU memory reserved: 0.00 GB
CUDA is available: True

import torch
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split

if torch.cuda.is_available():
   
    num_devices = torch.cuda.device_count()
    print(f"Number of available GPUs: {num_devices}")
else:
    print("CUDA is not available")

/opt/conda/lib/python3.10/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.23.5
  warnings.warn(f"A NumPy version >={np_minversion} and <{np_maxversion}"

Number of available GPUs: 2

import numpy as np
from numpy import expand_dims
import pandas as pd
import json
import matplotlib.pyplot as plt
import seaborn as sns
import os
import sys

with open('/kaggle/input/ships-in-satellite-imagery/shipsnet.json') as data_file:
    dataset = json.load(data_file)
shipsnet= pd.DataFrame(dataset)
shipsnet.head()

	data	labels	locations	scene_ids
0	[82, 89, 91, 87, 89, 87, 86, 86, 86, 86, 84, 8...	1	[-118.2254694333423, 33.73803725920789]	20180708_180909_0f47
1	[76, 75, 67, 62, 68, 72, 73, 73, 68, 69, 69, 6...	1	[-122.33222866289329, 37.7491755586813]	20170705_180816_103e
2	[125, 127, 129, 130, 126, 125, 129, 133, 132, ...	1	[-118.14283073363218, 33.736016066914175]	20180712_211331_0f06
3	[102, 99, 113, 106, 96, 102, 105, 105, 103, 10...	1	[-122.34784341495181, 37.76648707436548]	20170609_180756_103a
4	[78, 76, 74, 78, 79, 79, 79, 82, 86, 85, 83, 8...	1	[-122.34852408322172, 37.75878462398653]	20170515_180653_1007

shipsnet.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4000 entries, 0 to 3999
Data columns (total 4 columns):
 #   Column     Non-Null Count  Dtype 
---  ------     --------------  ----- 
 0   data       4000 non-null   object
 1   labels     4000 non-null   int64 
 2   locations  4000 non-null   object
 3   scene_ids  4000 non-null   object
dtypes: int64(1), object(3)
memory usage: 125.1+ KB

shipsnet = shipsnet[["data", "labels"]]
shipsnet.head()

	data	labels
0	[82, 89, 91, 87, 89, 87, 86, 86, 86, 86, 84, 8...	1
1	[76, 75, 67, 62, 68, 72, 73, 73, 68, 69, 69, 6...	1
2	[125, 127, 129, 130, 126, 125, 129, 133, 132, ...	1
3	[102, 99, 113, 106, 96, 102, 105, 105, 103, 10...	1
4	[78, 76, 74, 78, 79, 79, 79, 82, 86, 85, 83, 8...	1

len(shipsnet["data"].iloc[0])

19200

ship_images = shipsnet["labels"].value_counts()[0]
no_ship_images = shipsnet["labels"].value_counts()[1]
print("Number of the ship_images :{}".format(ship_images),"\n")
print("Number of the no ship_images :{}".format(no_ship_images))

Number of the ship_images :3000 

Number of the no ship_images :1000

x = np.array(dataset['data']).astype('uint8')
y = np.array(dataset['labels']).astype('uint8')

x_reshaped = x.reshape(-1, 3, 80, 80).transpose(0, 2, 3, 1)
x_reshaped = x_reshaped / 255

y_reshaped = np.eye(2)[y]

from sklearn.model_selection import train_test_split

x_train_1, x_test, y_train_1, y_test = train_test_split(x_reshaped, y_reshaped, test_size=0.20, random_state=42)

x_train, x_val, y_train, y_val = train_test_split(x_train_1, y_train_1, test_size=0.25, random_state=42)

from torch.utils.data import Dataset, TensorDataset, DataLoader

x_train_torch = torch.tensor(np.transpose(x_train, (0, 3, 1, 2)), dtype=torch.float32)
y_train_torch = torch.tensor(y_train, dtype=torch.float32)
x_val_torch = torch.tensor(np.transpose(x_val, (0, 3, 1, 2)), dtype=torch.float32)
y_val_torch = torch.tensor(y_val, dtype=torch.float32)

train_dataset = TensorDataset(x_train_torch, y_train_torch)
val_dataset = TensorDataset(x_val_torch, y_val_torch)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from torchvision.transforms import Normalize
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(64)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.dropout1 = nn.Dropout(0.25)

        self.conv2 = nn.Conv2d(64, 64, 3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.dropout2 = nn.Dropout(0.25)

        self.conv3 = nn.Conv2d(64, 64, 3, padding=1)
        self.bn3 = nn.BatchNorm2d(64)
        self.pool3 = nn.MaxPool2d(2, 2)
        self.dropout3 = nn.Dropout(0.25)

        self.conv4 = nn.Conv2d(64, 64, 3, padding=1)
        self.bn4 = nn.BatchNorm2d(64)
        self.pool4 = nn.MaxPool2d(2, 2)
        self.dropout4 = nn.Dropout(0.25)

        self.flatten = nn.Flatten()

        self.fc1 = nn.Linear(64 * 5 * 5, 200)
        self.fc2 = nn.Linear(200, 150)
        self.fc3 = nn.Linear(150, 2)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = self.pool1(x)
        x = self.dropout1(x)

        x = F.relu(self.bn2(self.conv2(x)))
        x = self.pool2(x)
        x = self.dropout2(x)

        x = F.relu(self.bn3(self.conv3(x)))
        x = self.pool3(x)
        x = self.dropout3(x)

        x = F.relu(self.bn4(self.conv4(x)))
        x = self.pool4(x)
        x = self.dropout4(x)

        x = self.flatten(x)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = F.softmax(self.fc3(x), dim=1)
        return x

model = Net()
# Move the model to GPU(s)
if torch.cuda.is_available():
    model = model.cuda()
    if torch.cuda.device_count() > 1:
        model = nn.DataParallel(model)
        
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

num_epochs = 100
early_stop_patience = 10
best_val_loss = float('inf')
counter = 0

train_losses = []
train_accuracies = []
val_losses = []
val_accuracies = []

for epoch in range(num_epochs):
    train_loss = 0
    train_correct = 0
    val_loss = 0
    val_correct = 0

    model.train()
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs = inputs.cuda()
        labels = labels.cuda().argmax(dim=1)  # Convert one-hot encoded labels to class indices
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

        train_loss += loss.item()
        _, predicted = torch.max(outputs, 1)
        train_correct += (predicted == labels).sum().item()

    model.eval()
    val_loss = 0.0
    with torch.no_grad():
        for inputs, labels in val_loader:
            inputs = inputs.cuda()
            labels = labels.cuda().argmax(dim=1)  # Convert one-hot encoded labels to class indices
            outputs = model(inputs)
            loss = criterion(outputs, labels)

            val_loss += loss.item()
            _, predicted = torch.max(outputs, 1)
            val_correct += (predicted == labels).sum().item()

    train_losses.append(train_loss / len(train_loader))
    train_accuracies.append(100 * train_correct / len(train_loader.dataset))
    val_losses.append(val_loss / len(val_loader))
    val_accuracies.append(100 * val_correct / len(val_loader.dataset))

    print(f"Epoch {epoch + 1}/{num_epochs}, Train Loss: {train_losses[-1]:.4f}, Train Acc: {train_accuracies[-1]:.2f}%, Val Loss: {val_losses[-1]:.4f}, Val Acc: {val_accuracies[-1]:.2f}%")

    if val_loss < best_val_loss:
        best_val_loss = val_loss
        torch.save(model.state_dict(), 'best_model.pth')
        counter = 0
    else:
        counter += 1
        if counter >= early_stop_patience:
            print(f"Early stopping after {counter} epochs with no improvement.")
            break

model.load_state_dict(torch.load('best_model.pth'))

Epoch 1/100, Train Loss: 0.4542, Train Acc: 85.92%, Val Loss: 0.4644, Val Acc: 84.25%
Epoch 2/100, Train Loss: 0.3912, Train Acc: 92.08%, Val Loss: 0.3747, Val Acc: 93.62%
Epoch 3/100, Train Loss: 0.3613, Train Acc: 95.17%, Val Loss: 0.3712, Val Acc: 95.00%
Epoch 4/100, Train Loss: 0.3485, Train Acc: 96.58%, Val Loss: 0.3704, Val Acc: 93.88%
Epoch 5/100, Train Loss: 0.3511, Train Acc: 96.04%, Val Loss: 0.3437, Val Acc: 97.00%
Epoch 6/100, Train Loss: 0.3348, Train Acc: 97.75%, Val Loss: 0.3456, Val Acc: 96.62%
Epoch 7/100, Train Loss: 0.3314, Train Acc: 98.17%, Val Loss: 0.3409, Val Acc: 97.00%
Epoch 8/100, Train Loss: 0.3339, Train Acc: 97.96%, Val Loss: 0.3507, Val Acc: 96.00%
Epoch 9/100, Train Loss: 0.3336, Train Acc: 97.96%, Val Loss: 0.3480, Val Acc: 96.38%
Epoch 10/100, Train Loss: 0.3291, Train Acc: 98.46%, Val Loss: 0.3458, Val Acc: 96.75%
Epoch 11/100, Train Loss: 0.3261, Train Acc: 98.62%, Val Loss: 0.3342, Val Acc: 98.00%
Epoch 12/100, Train Loss: 0.3225, Train Acc: 99.12%, Val Loss: 0.3353, Val Acc: 97.75%
Epoch 13/100, Train Loss: 0.3253, Train Acc: 98.71%, Val Loss: 0.3295, Val Acc: 98.38%
Epoch 14/100, Train Loss: 0.3264, Train Acc: 98.62%, Val Loss: 0.3415, Val Acc: 97.12%
Epoch 15/100, Train Loss: 0.3227, Train Acc: 99.00%, Val Loss: 0.3290, Val Acc: 98.38%
Epoch 16/100, Train Loss: 0.3195, Train Acc: 99.42%, Val Loss: 0.3303, Val Acc: 98.25%
Epoch 17/100, Train Loss: 0.3186, Train Acc: 99.50%, Val Loss: 0.3329, Val Acc: 98.12%
Epoch 18/100, Train Loss: 0.3190, Train Acc: 99.50%, Val Loss: 0.3368, Val Acc: 97.62%
Epoch 19/100, Train Loss: 0.3246, Train Acc: 98.83%, Val Loss: 0.3395, Val Acc: 97.38%
Epoch 20/100, Train Loss: 0.3231, Train Acc: 98.96%, Val Loss: 0.3307, Val Acc: 98.25%
Epoch 21/100, Train Loss: 0.3213, Train Acc: 99.25%, Val Loss: 0.3349, Val Acc: 97.88%
Epoch 22/100, Train Loss: 0.3188, Train Acc: 99.46%, Val Loss: 0.3310, Val Acc: 98.25%
Epoch 23/100, Train Loss: 0.3174, Train Acc: 99.62%, Val Loss: 0.3279, Val Acc: 98.50%
Epoch 24/100, Train Loss: 0.3277, Train Acc: 98.54%, Val Loss: 0.3470, Val Acc: 96.62%
Epoch 25/100, Train Loss: 0.3252, Train Acc: 98.67%, Val Loss: 0.3408, Val Acc: 97.12%
Epoch 26/100, Train Loss: 0.3226, Train Acc: 99.04%, Val Loss: 0.3400, Val Acc: 97.12%
Epoch 27/100, Train Loss: 0.3376, Train Acc: 97.46%, Val Loss: 0.3385, Val Acc: 97.38%
Epoch 28/100, Train Loss: 0.3275, Train Acc: 98.50%, Val Loss: 0.3463, Val Acc: 96.62%
Epoch 29/100, Train Loss: 0.3243, Train Acc: 98.88%, Val Loss: 0.3339, Val Acc: 97.75%
Epoch 30/100, Train Loss: 0.3176, Train Acc: 99.58%, Val Loss: 0.3274, Val Acc: 98.62%
Epoch 31/100, Train Loss: 0.3160, Train Acc: 99.71%, Val Loss: 0.3311, Val Acc: 98.12%
Epoch 32/100, Train Loss: 0.3177, Train Acc: 99.58%, Val Loss: 0.3329, Val Acc: 98.00%
Epoch 33/100, Train Loss: 0.3274, Train Acc: 98.54%, Val Loss: 0.3330, Val Acc: 98.00%
Epoch 34/100, Train Loss: 0.3165, Train Acc: 99.67%, Val Loss: 0.3299, Val Acc: 98.25%
Epoch 35/100, Train Loss: 0.3172, Train Acc: 99.62%, Val Loss: 0.3285, Val Acc: 98.25%
Epoch 36/100, Train Loss: 0.3160, Train Acc: 99.71%, Val Loss: 0.3342, Val Acc: 97.75%
Epoch 37/100, Train Loss: 0.3172, Train Acc: 99.58%, Val Loss: 0.3330, Val Acc: 98.00%
Epoch 38/100, Train Loss: 0.3167, Train Acc: 99.71%, Val Loss: 0.3241, Val Acc: 98.88%
Epoch 39/100, Train Loss: 0.3164, Train Acc: 99.71%, Val Loss: 0.3247, Val Acc: 98.88%
Epoch 40/100, Train Loss: 0.3153, Train Acc: 99.79%, Val Loss: 0.3258, Val Acc: 98.75%
Epoch 41/100, Train Loss: 0.3174, Train Acc: 99.58%, Val Loss: 0.3266, Val Acc: 98.62%
Epoch 42/100, Train Loss: 0.3153, Train Acc: 99.79%, Val Loss: 0.3357, Val Acc: 97.75%
Epoch 43/100, Train Loss: 0.3188, Train Acc: 99.46%, Val Loss: 0.3305, Val Acc: 98.25%
Epoch 44/100, Train Loss: 0.3249, Train Acc: 98.79%, Val Loss: 0.3295, Val Acc: 98.38%
Epoch 45/100, Train Loss: 0.3200, Train Acc: 99.33%, Val Loss: 0.3314, Val Acc: 98.12%
Epoch 46/100, Train Loss: 0.3184, Train Acc: 99.46%, Val Loss: 0.3321, Val Acc: 98.00%
Epoch 47/100, Train Loss: 0.3246, Train Acc: 98.92%, Val Loss: 0.3386, Val Acc: 97.50%
Epoch 48/100, Train Loss: 0.3191, Train Acc: 99.42%, Val Loss: 0.3352, Val Acc: 97.88%
Early stopping after 10 epochs with no improvement.

<All keys matched successfully>

print(model)

DataParallel(
  (module): Net(
    (conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (dropout1): Dropout(p=0.25, inplace=False)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (dropout2): Dropout(p=0.25, inplace=False)
    (conv3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (bn3): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (pool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (dropout3): Dropout(p=0.25, inplace=False)
    (conv4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (bn4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (pool4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (dropout4): Dropout(p=0.25, inplace=False)
    (flatten): Flatten(start_dim=1, end_dim=-1)
    (fc1): Linear(in_features=1600, out_features=200, bias=True)
    (fc2): Linear(in_features=200, out_features=150, bias=True)
    (fc3): Linear(in_features=150, out_features=2, bias=True)
  )
)

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(train_losses, label="Training Loss")
plt.plot(val_losses, label="Validation Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(train_accuracies, label="Training Accuracy")
plt.plot(val_accuracies, label="Validation Accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.legend()

plt.show()

x_test_torch = torch.tensor(np.transpose(x_test, (0, 3, 1, 2)), dtype=torch.float32).cuda()
y_test_torch = torch.tensor(y_test, dtype=torch.float32).cuda()


test_dataset = TensorDataset(x_test_torch, y_test_torch)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)


model.eval()
correct = 0
total = 0

with torch.no_grad():
    inputs = inputs.cuda()  
    labels = labels.cuda() 
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        _, labels = torch.max(labels, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print("Test Accuracy: {:.2f}%".format(accuracy))

Test Accuracy: 99.00%

with torch.no_grad():
    predictions = model(x_test_torch)

probabilities = F.softmax(predictions, dim=1).cpu().numpy()

import pandas as pd

single_prediction = pd.Series(probabilities[2], index=["Not A Ship", "Ship"])
print(single_prediction)

Not A Ship    0.268941
Ship          0.731059
dtype: float32

import matplotlib.pyplot as plt


first_test_image = x_test[2]


plt.imshow(first_test_image)
plt.title("First Test Image")
plt.axis("off")
plt.show()

import cv2
import numpy as np
import matplotlib.pyplot as plt

def scanmap(image_path):
    

    satellite_image = cv2.imread(image_path)

    satellite_image = satellite_image.astype(np.float32) / 255.0

    window_size = (80, 80)
    stride = 10

    height, width, channels = satellite_image.shape

    probabilities_map = []

    for y in range(0, height - window_size[1] + 1, stride):
        row_probabilities = []
        for x in range(0, width - window_size[0] + 1, stride):
            cropped_window = satellite_image[y:y + window_size[1], x:x + window_size[0]]
            cropped_window_torch = torch.tensor(cropped_window.transpose(2, 0, 1), dtype=torch.float32).unsqueeze(0).cpu()
        
            with torch.no_grad():
                probabilities = model(cropped_window_torch)
        
            row_probabilities.append(probabilities[0, 1].item())
    
        probabilities_map.append(row_probabilities)

    probabilities_map = np.array(probabilities_map)

    

    plt.imshow(probabilities_map, cmap='hot', interpolation='nearest')
    plt.colorbar()
    plt.show()

scanmap("/kaggle/input/images/close_1png.png")

using_colab = True

if using_colab:
    import torch
    import torchvision
    print("PyTorch version:", torch.__version__)
    print("Torchvision version:", torchvision.__version__)
    print("CUDA is available:", torch.cuda.is_available())
    import sys
    !{sys.executable} -m pip install opencv-python matplotlib
    !{sys.executable} -m pip install 'git+https://github.com/facebookresearch/segment-anything.git'
    
    !mkdir images
    !wget -P images https://raw.githubusercontent.com/facebookresearch/segment-anything/main/notebooks/images/dog.jpg
        
    !wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth

PyTorch version: 2.0.0
Torchvision version: 0.15.1
CUDA is available: True
Requirement already satisfied: opencv-python in /opt/conda/lib/python3.10/site-packages (4.5.4.60)
Requirement already satisfied: matplotlib in /opt/conda/lib/python3.10/site-packages (3.6.3)
Requirement already satisfied: numpy>=1.21.2 in /opt/conda/lib/python3.10/site-packages (from opencv-python) (1.23.5)
Requirement already satisfied: kiwisolver>=1.0.1 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (1.4.4)
Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (21.3)
Requirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (2.8.2)
Requirement already satisfied: contourpy>=1.0.1 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (1.0.7)
Requirement already satisfied: pillow>=6.2.0 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (9.5.0)
Requirement already satisfied: pyparsing>=2.2.1 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (3.0.9)
Requirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (4.39.3)
Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.10/site-packages (from matplotlib) (0.11.0)
Requirement already satisfied: six>=1.5 in /opt/conda/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
Collecting git+https://github.com/facebookresearch/segment-anything.git
  Cloning https://github.com/facebookresearch/segment-anything.git to /tmp/pip-req-build-1zz8twph
  Running command git clone --filter=blob:none --quiet https://github.com/facebookresearch/segment-anything.git /tmp/pip-req-build-1zz8twph
  Resolved https://github.com/facebookresearch/segment-anything.git to commit 6fdee8f2727f4506cfbbe553e23b895e27956588
  Preparing metadata (setup.py) ... done
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
--2023-05-08 19:01:06--  https://raw.githubusercontent.com/facebookresearch/segment-anything/main/notebooks/images/dog.jpg
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 99846 (98K) [image/jpeg]
Saving to: ‘images/dog.jpg’

dog.jpg             100%[===================>]  97.51K  --.-KB/s    in 0.01s   

2023-05-08 19:01:06 (8.27 MB/s) - ‘images/dog.jpg’ saved [99846/99846]

--2023-05-08 19:01:07--  https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
Resolving dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)... 52.84.162.119, 52.84.162.20, 52.84.162.103, ...
Connecting to dl.fbaipublicfiles.com (dl.fbaipublicfiles.com)|52.84.162.119|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 2564550879 (2.4G) [binary/octet-stream]
Saving to: ‘sam_vit_h_4b8939.pth’

sam_vit_h_4b8939.pt 100%[===================>]   2.39G   241MB/s    in 11s     

2023-05-08 19:01:18 (229 MB/s) - ‘sam_vit_h_4b8939.pth’ saved [2564550879/2564550879]

import numpy as np
import torch
import matplotlib.pyplot as plt
import cv2

image = cv2.imread('/kaggle/input/ships-in-satellite-imagery/scenes/scenes/sfbay_1.png')
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

plt.figure(figsize=(20,20))
plt.imshow(image)
plt.axis('off')
plt.show()

import sys
sys.path.append("..")
from segment_anything import sam_model_registry, SamAutomaticMaskGenerator, SamPredictor

sam_checkpoint = "sam_vit_h_4b8939.pth"
model_type = "vit_h"

device = "cuda"

sam = sam_model_registry[model_type](checkpoint=sam_checkpoint)
sam.to(device=device)

mask_generator = SamAutomaticMaskGenerator(sam)

masks = mask_generator.generate(image)

print(len(masks))
print(masks[0].keys())

51
dict_keys(['segmentation', 'area', 'bbox', 'predicted_iou', 'point_coords', 'stability_score', 'crop_box'])

def show_anns(anns):
    if len(anns) == 0:
        return
    sorted_anns = sorted(anns, key=(lambda x: x['area']), reverse=True)
    ax = plt.gca()
    ax.set_autoscale_on(False)
    polygons = []
    color = []
    for ann in sorted_anns:
        m = ann['segmentation']
        img = np.ones((m.shape[0], m.shape[1], 3))
        color_mask = np.random.random((1, 3)).tolist()[0]
        for i in range(3):
            img[:,:,i] = color_mask[i]
        ax.imshow(np.dstack((img, m*0.35)))

plt.figure(figsize=(20,20))
plt.imshow(image)
show_anns(masks)
plt.axis('off')
plt.show() 

import os
import json
import shutil
from PIL import Image
import numpy as np
from sklearn.model_selection import train_test_split

def save_image_from_data(data, label, output_path):
    image_data = np.array(data, dtype='uint8').reshape((80, 80, 3))
    img = Image.fromarray(image_data, 'RGB')
    img.save(output_path)
    return output_path



def split_data_into_train_test(input_path, train_path, test_path, test_ratio=0.2):
    with open(input_path, 'r') as f:
        dataset = json.load(f)

    if not os.path.exists(train_path):
        os.makedirs(train_path)
        os.makedirs(os.path.join(train_path, 'ship'))
        os.makedirs(os.path.join(train_path, 'non_ship'))

    if not os.path.exists(test_path):
        os.makedirs(test_path)
        os.makedirs(os.path.join(test_path, 'ship'))
        os.makedirs(os.path.join(test_path, 'non_ship'))

    images_and_labels = [(save_image_from_data(data, label, f"/kaggle/working/temp/{i}.png"), label)
                         for i, (data, label) in enumerate(zip(dataset['data'], dataset['labels']))]

    train_data, test_data = train_test_split(images_and_labels, test_size=test_ratio, random_state=42, stratify=[label for _, label in images_and_labels])

    for i, (image_path, label) in enumerate(train_data):
        class_folder = 'ship' if label == 1 else 'non_ship'
        shutil.move(image_path, os.path.join(train_path, class_folder, f"{i}.png"))

    for i, (image_path, label) in enumerate(test_data):
        class_folder = 'ship' if label == 1 else 'non_ship'
        shutil.move(image_path, os.path.join(test_path, class_folder, f"{i}.png"))

    shutil.rmtree('/kaggle/working/temp')

input_path = "/kaggle/input/ships-in-satellite-imagery/shipsnet.json"
train_path = "/kaggle/working/train/data"
test_path = "/kaggle/working/test/data"

os.makedirs('/kaggle/working/temp', exist_ok=True)
split_data_into_train_test(input_path, train_path, test_path)

import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from torch.optim import Adam
from torchvision.transforms import Compose, ToTensor, Normalize
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder


def load_ship_data(train_path, test_path, train_batch_size=64, test_batch_size=64):
    transform = Compose([
        ToTensor(),
        Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])

    train_loader = DataLoader(
        ImageFolder(train_path, transform=transform),
        batch_size=train_batch_size, shuffle=True)

    test_loader = DataLoader(
        ImageFolder(test_path, transform=transform),
        batch_size=test_batch_size, shuffle=False)

    return train_loader, test_loader


class Net(torch.nn.Module):
    def __init__(self, dims):
        super().__init__()
        self.layers = []
        self.loss_history = []
        self.train_accuracy_history = []
        for d in range(len(dims) - 1):
            self.layers += [Layer(dims[d], dims[d + 1]).cuda()]

    def predict(self, x):
        h = x
        for layer in self.layers:
            h = layer(h)
        return h.argmax(1)

    def train(self, x_pos, x_neg, y):
        h_pos, h_neg = x_pos, x_neg
        for i, layer in enumerate(self.layers):
            print('training layer', i, '...')
            h_pos, h_neg, epoch_losses = layer.train(h_pos, h_neg)
            self.loss_history.extend(epoch_losses)
            train_accuracy = (self.predict(x_pos).eq(y[y == 1]).float().mean().item(),
                              self.predict(x_neg).eq(y[y == 0]).float().mean().item())
            self.train_accuracy_history.append(train_accuracy)


class Layer(nn.Linear):
    def __init__(self, in_features, out_features,
                 bias=True, device=None, dtype=None):
        super().__init__(in_features, out_features, bias, device, dtype)
        self.relu = torch.nn.ReLU()
        self.opt = Adam(self.parameters(), lr=0.03)
        self.threshold = 2.0
        self.num_epochs = 1000

    def forward(self, x):
        x_direction = x / (x.norm(2, 1, keepdim=True) + 1e-4)
        x_flattened = x_direction.reshape(x_direction.size(0), -1)
        return self.relu(
            torch.mm(x_flattened, self.weight.T) +
            self.bias.unsqueeze(0))


    def train(self, x_pos, x_neg):
        epoch_losses = []
        for i in range(self.num_epochs):
            g_pos = self.forward(x_pos).pow(2).mean(1)
            g_neg = self.forward(x_neg).pow(2).mean(1)
            loss = torch.log(1 + torch.exp(torch.cat([
                -g_pos + self.threshold,
                g_neg - self.threshold]))).mean()
            self.opt.zero_grad()
            loss.backward()
            self.opt.step()
            epoch_losses.append(loss.item())
        return self.forward(x_pos).detach(), self.forward(x_neg).detach(), epoch_losses



if __name__ == "__main__":
    torch.manual_seed(1234)

    train_path = "/kaggle/working/train/data"
    test_path = "/kaggle/working/test/data"
    train_loader, test_loader = load_ship_data(train_path, test_path)

    net = Net([19200, 500, 500, 2])  
    x, y = next(iter(train_loader))
    x, y = x.cuda(), y.cuda()
    x_pos = x[y == 1]
    x_neg = x[y == 0]

    net.train(x_pos, x_neg,y)

    x_train, y_train = next(iter(train_loader))
    x_train, y_train = x_train.cuda(), y_train.cuda()
    train_accuracy = net.predict(x_train).eq(y_train).float().mean().item()
    print('train accuracy:', train_accuracy)

    x_test, y_test = next(iter(test_loader))
    x_test, y_test = x_test.cuda(), y_test.cuda()
    test_accuracy = net.predict(x_test).eq(y_test).float().mean().item()
    print('test accuracy:', test_accuracy)

training layer 0 ...
training layer 1 ...
training layer 2 ...
train accuracy: 0.734375
test accuracy: 1.0

Article of FF-Algorithm [Github Link](https://github.com/mohammadpz/pytorch_forward_forward